.TH std::is_pointer_interconvertible_with_class 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_pointer_interconvertible_with_class \- std::is_pointer_interconvertible_with_class

.SH Synopsis
   Defined in header <type_traits>
   template< class S, class M >
   constexpr bool is_pointer_interconvertible_with_class( M S::* mp )     \fI(since C++20)\fP
   noexcept;

   Given an object s of type S, determines whether s.*mp refers to a subobject of s and
   s is pointer-interconvertible with its subobject s.*mp. The program is ill-formed if
   S is not a complete type.

   If S is not a StandardLayoutType, or M is not an object type, or mp is equal to
   nullptr, the result is always false.

.SH Parameters

   mp - a pointer-to-member to detect

.SH Return value

   true if s.*mp refers a subobject of s and s is pointer-interconvertible with its
   subobject s.*mp, otherwise false, where s is an object of type S.

.SH Notes

   The type of a pointer-to-member expression &S::m is not always M S::*, where m is of
   type M, because m may be a member inherited from a base class of S. The template
   arguments can be specified in order to avoid potentially surprising results.

   If there is a value mp of type M S::* such that
   std::is_pointer_interconvertible_with_class(mp) == true, then
   reinterpret_cast<M&>(s) has well-defined result and it refers the same subobject as
   s.*mp, where s is a valid lvalue of type S.

   On common platforms, the bit pattern of mp is all zero if
   std::is_pointer_interconvertible_with_class(mp) == true.

         Feature-test macro            Value    Std                       Feature
                                                      Pointer-interconvertibility traits:
__cpp_lib_is_pointer_interconvertible 201907L (C++20)   * std::is_pointer_interconvertible_base_of,
                                                        * std::is_pointer_interconvertible_with_class

.SH Example


// Run this code

 #include <type_traits>

 struct Foo { int x; };
 struct Bar { int y; };

 struct Baz : Foo, Bar {}; // not standard-layout

 static_assert( not std::is_same_v<decltype(&Baz::x), int Baz::*> );
 static_assert( std::is_pointer_interconvertible_with_class(&Baz::x) );
 static_assert( not std::is_pointer_interconvertible_with_class<Baz, int>(&Baz::x) );

 int main() { }

.SH See also

   is_standard_layout       checks if a type is a standard-layout type
   \fI(C++11)\fP                  \fI(class template)\fP
   is_member_object_pointer checks if a type is a pointer to a non-static member object
   \fI(C++11)\fP                  \fI(class template)\fP
